/*Este archivo se ocupa de la impresión estética de los programas*/
package simple.analysis;

import java.util.*;
import simple.node.*;
import simple.analysis.*;

public class Pretty extends DepthFirstAdapter
{
    final String tab = "    ";

    private Hashtable tabulaciones = new Hashtable();
    private Hashtable tab_record   = new Hashtable();

    /* Metodos para pon/coge valores de nodos AST  */
    private void ponValor(Node node, int value)
    {
        tabulaciones.put(node, new Integer(value));
    }

    private int cogeValor(Node node)
    {
        Integer value = (Integer) tabulaciones.get(node);
        return value.intValue();
    }

    private void ponTabRecord(Node node, int value)
    {
        tab_record.put(node, new Integer(value));
    }

    private int cogeTabRecord(Node node)
    {
        Integer value = (Integer) tab_record.get(node);
        return value.intValue();
    }

    /* Metodos de DepthFirstAdapter */
    public void inStart(Start node)
    {
        defaultIn(node);
    }

    public void outStart(Start node)
    {
        defaultOut(node);
    }

    public void defaultIn(Node node)
    {
    }

    public void defaultOut(Node node)
    {
    }

    public void caseStart(Start node)
    {
        inStart(node);
        node.getPPrograma().apply(this);
        node.getEOF().apply(this);
        outStart(node);
    }

    public void inAPrograma(APrograma node)
    {
        defaultIn(node);
    }

    public void outAPrograma(APrograma node)
    {
        defaultOut(node);
    }

    public void caseAPrograma(APrograma node)
    {
        inAPrograma(node);
        if(node.getDecGlob() != null)
        {
            ponValor(node.getDecGlob(), 0); //inicializamos la tabulación a 0
            node.getDecGlob().apply(this);
        }
        {
            Object temp[] = node.getDefFunc().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ponValor(((PDefFunc) temp[i]), 0); //inicializamos la tabulación a 0
                ((PDefFunc) temp[i]).apply(this);
            }
        }
        outAPrograma(node);
    }

    public void inADecGlob(ADecGlob node)
    {
        defaultIn(node);
    }

    public void outADecGlob(ADecGlob node)
    {
        defaultOut(node);
    }

    public void caseADecGlob(ADecGlob node)
    {
        inADecGlob(node);
        if(node.getDecGlobal() != null)
        {
            node.getDecGlobal().apply(this);
        }
        /*Imprimimos la palabra reservada dec global*/
        for (int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.println(node.getDecGlobal());

        {
            Object temp[] = node.getNuevoTipo().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ponValor(((PNuevoTipo) temp[i]), cogeValor(node) + 1);
                ((PNuevoTipo) temp[i]).apply(this);
            }
        }
        {
            Object temp[] = node.getDecVars().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ponValor(((PDecVars) temp[i]), cogeValor(node) + 1);
                ((PDecVars) temp[i]).apply(this);
            }
        }
        {
            Object temp[] = node.getDecFuncs().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ponValor(((PDecFuncs) temp[i]), cogeValor(node) + 1);
                ((PDecFuncs) temp[i]).apply(this);
            }
        }
        if(node.getEndGlobal() != null)
        {
            node.getEndGlobal().apply(this);
        }
        /*Imprimimos la palabra reservada end dec global*/
        for (int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.println(node.getEndGlobal());

        outADecGlob(node);
    }

    public void inADecVars(ADecVars node)
    {
        defaultIn(node);
    }

    public void outADecVars(ADecVars node)
    {
        defaultOut(node);
    }

    public void caseADecVars(ADecVars node)
    {
        inADecVars(node);
        if(node.getVar() != null)
        {
            node.getVar().apply(this);
        }
        /*Imprimimos la palabra reservada var*/
        for (int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getVar());
        ponTabRecord(node.getVar(), ((node.getVar()).toString()).length());

        if(node.getListId() != null)
        {
            ponTabRecord(node.getListId(), 0);
            ponValor(node.getListId(),0); //Ponemos a 0 el numero de tab
            node.getListId().apply(this);
        }
    
        if(node.getDosPuntos() != null)
        {
            node.getDosPuntos().apply(this);
        }
        /*Imprimimos ':'*/
        System.out.print(node.getDosPuntos());
        ponTabRecord(node.getDosPuntos(), ((node.getDosPuntos()).toString()).length());
        
        if(node.getTipoVariable() != null)
        {
            ponValor(node.getTipoVariable(), cogeValor(node) + (cogeTabRecord(node.getVar())  +
                         cogeTabRecord(node.getListId()) + cogeTabRecord(node.getDosPuntos()))/4); //ponemos la tab_record 
            node.getTipoVariable().apply(this);
        }
        if(node.getPyc() != null)
        {
            node.getPyc().apply(this);
        }
        /*Imprimimos el pyc*/
        System.out.println(node.getPyc());
        outADecVars(node);
    }

    public void inADecFuncs(ADecFuncs node)
    {
        defaultIn(node);
    }

    public void outADecFuncs(ADecFuncs node)
    {
        defaultOut(node);
    }

    public void caseADecFuncs(ADecFuncs node)
    {
        inADecFuncs(node);
        if(node.getForward() != null)
        {
            node.getForward().apply(this);
        }

        /*Imprimimos forward*/
        for (int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getForward());

        if(node.getListFunc() != null)
        {
            ponValor(node.getListFunc(),0);
            node.getListFunc().apply(this);
        }
        if(node.getPyc() != null)
        {
            node.getPyc().apply(this);
        }
        /*Imprimimos el pyc*/
        System.out.println(node.getPyc());
        outADecFuncs(node);

    }

    public void inAUnoListFunc(AUnoListFunc node)
    {
        defaultIn(node);
    }

    public void outAUnoListFunc(AUnoListFunc node)
    {
        defaultOut(node);
    }

    public void caseAUnoListFunc(AUnoListFunc node)
    {
        inAUnoListFunc(node);
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        /*Imprimimos el id*/
        for (int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getId());

        if(node.getAParen() != null)
        {
            node.getAParen().apply(this);
        }
        /*Imprimimos '('*/
        System.out.print(node.getAParen());

        if(node.getCParen() != null)
        {
            node.getCParen().apply(this);
        }
        /*Imprimimos ')'*/
        System.out.print(node.getCParen());
 
       if(node.getDosPuntos() != null)
        {
            node.getDosPuntos().apply(this);
        }
        /*Imprimimos :)'*/
        System.out.print(": ");

       if(node.getTipoConNombre() != null)
        {
            ponValor(node.getTipoConNombre(), 0);
            node.getTipoConNombre().apply(this);
        }
        outAUnoListFunc(node);
    }

    public void inAVariosListFunc(AVariosListFunc node)
    {
        defaultIn(node);
    }

    public void outAVariosListFunc(AVariosListFunc node)
    {
        defaultOut(node);
    }

    public void caseAVariosListFunc(AVariosListFunc node)
    {
        inAVariosListFunc(node);
        if(node.getListFunc() != null)
        {
            ponValor(node.getListFunc(), cogeValor(node));
            node.getListFunc().apply(this);
        }
        if(node.getComa() != null)
        {
            node.getComa().apply(this);
        }
        /*Imprimimos ','*/
        System.out.print(node.getComa());

        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        /*Imprimimos el id*/
        System.out.print(node.getId());

        if(node.getAParen() != null)
        {
            node.getAParen().apply(this);
        }
        /*Imprimimos '('*/
        System.out.print(node.getAParen());

        if(node.getCParen() != null)
        {
            node.getCParen().apply(this);
        }
        /*Imprimimos ')'*/
        System.out.print(node.getCParen());
 
       if(node.getDosPuntos() != null)
        {
            node.getDosPuntos().apply(this);
        }
        /*Imprimimos :)'*/
        System.out.print(": ");

       if(node.getTipoConNombre() != null)
        {
            ponValor(node.getTipoConNombre(), 0);
            node.getTipoConNombre().apply(this);
        }
        outAVariosListFunc(node);
    }

    public void inANuevoTipo(ANuevoTipo node)
    {
        defaultIn(node);
    }

    public void outANuevoTipo(ANuevoTipo node)
    {
        defaultOut(node);
    }

    public void caseANuevoTipo(ANuevoTipo node)
    {
        inANuevoTipo(node);
        if(node.getTypedef() != null)
        {
            node.getTypedef().apply(this);
        }
        /*Imprimimos typedef*/
        for(int i = 0; i < cogeValor(node);i++)
            System.out.print(tab);
        System.out.print(node.getTypedef());
        ponTabRecord(node.getTypedef(), ((node.getTypedef()).toString()).length());

        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        /*Imprimimos Id*/
        System.out.print(node.getId());
        ponTabRecord(node.getId(), ((node.getId()).toString()).length());
        
        if(node.getOpIgual() != null)
        {
            node.getOpIgual().apply(this);
        }
        /*Imprimimos Igual*/
        System.out.print(node.getOpIgual());
        ponTabRecord(node.getOpIgual(), ((node.getOpIgual()).toString()).length());

        if(node.getTipoVariable() != null)
        {
            ponValor(node.getTipoVariable(),cogeValor(node) + (cogeTabRecord(node.getTypedef()) +
                            cogeTabRecord(node.getId()) + cogeTabRecord(node.getOpIgual()))/4);
            node.getTipoVariable().apply(this);
        }

        if(node.getPyc() != null)
        {
            node.getPyc().apply(this);
        }
        /*Imprimimos Pyc*/
        System.out.println(node.getPyc());
        outANuevoTipo(node);
    }

    public void inAEnteroTipoConNombre(AEnteroTipoConNombre node)
    {
        defaultIn(node);
    }

    public void outAEnteroTipoConNombre(AEnteroTipoConNombre node)
    {
        defaultOut(node);
    }

    public void caseAEnteroTipoConNombre(AEnteroTipoConNombre node)
    {
        inAEnteroTipoConNombre(node);
        if(node.getInt() != null)
        {
            node.getInt().apply(this);
        }
        /*Imprimimos int*/
        //for(int i = 0; i < cogeValor(node);i++)
          //  System.out.print(tab);
        System.out.print(node.getInt());
        
        outAEnteroTipoConNombre(node);
    }

    public void inABooleanoTipoConNombre(ABooleanoTipoConNombre node)
    {
        defaultIn(node);
    }

    public void outABooleanoTipoConNombre(ABooleanoTipoConNombre node)
    {
        defaultOut(node);
    }

    public void caseABooleanoTipoConNombre(ABooleanoTipoConNombre node)
    {
        inABooleanoTipoConNombre(node);
        if(node.getBool() != null)
        {
            node.getBool().apply(this);
        }
        /*Imprimimos bool*/
        //for(int i = 0; i < cogeValor(node);i++)
          //  System.out.print(tab);
        System.out.print(node.getBool());
        outABooleanoTipoConNombre(node);
    }

    public void inAOtroTipoConNombre(AOtroTipoConNombre node)
    {
        defaultIn(node);
    }

    public void outAOtroTipoConNombre(AOtroTipoConNombre node)
    {
        defaultOut(node);
    }

    public void caseAOtroTipoConNombre(AOtroTipoConNombre node)
    {
        inAOtroTipoConNombre(node);
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        /*Imprimimos Id*/
    //    for(int i = 0; i < cogeValor(node);i++)
      //      System.out.print(tab);
        System.out.print(node.getId());

        outAOtroTipoConNombre(node);
    }

    public void inAPtrEnteroTipoConNombre(APtrEnteroTipoConNombre node)
    {
        defaultIn(node);
    }

    public void outAPtrEnteroTipoConNombre(APtrEnteroTipoConNombre node)
    {
        defaultOut(node);
    }

    public void caseAPtrEnteroTipoConNombre(APtrEnteroTipoConNombre node)
    {
        inAPtrEnteroTipoConNombre(node);
        if(node.getInt() != null)
        {
            node.getInt().apply(this);
        }
         /*Imprimimos int*/
//        for(int i = 0; i < cogeValor(node);i++)
  //          System.out.print(tab);
        System.out.print(node.getInt());

       if(node.getAsterisco() != null)
        {
            node.getAsterisco().apply(this);
        }
        /*Imprimimos '*' */
        System.out.print(node.getAsterisco());
        outAPtrEnteroTipoConNombre(node);
    }

    public void inAPtrBooleanoTipoConNombre(APtrBooleanoTipoConNombre node)
    {
        defaultIn(node);
    }

    public void outAPtrBooleanoTipoConNombre(APtrBooleanoTipoConNombre node)
    {
        defaultOut(node);
    }

    public void caseAPtrBooleanoTipoConNombre(APtrBooleanoTipoConNombre node)
    {
        inAPtrBooleanoTipoConNombre(node);
        if(node.getBool() != null)
        {
            node.getBool().apply(this);
        }
        /*Imprimimos bool*/
       // for(int i = 0; i < cogeValor(node);i++)
         //   System.out.print(tab);
        System.out.print(node.getBool());
       
        if(node.getAsterisco() != null)
        {
            node.getAsterisco().apply(this);
        }
        /*Imprimimos '*' */
        System.out.print(node.getAsterisco());
    
        outAPtrBooleanoTipoConNombre(node);
    }

    public void inAPtrOtroTipoConNombre(APtrOtroTipoConNombre node)
    {
        defaultIn(node);
    }

    public void outAPtrOtroTipoConNombre(APtrOtroTipoConNombre node)
    {
        defaultOut(node);
    }

    public void caseAPtrOtroTipoConNombre(APtrOtroTipoConNombre node)
    {
        inAPtrOtroTipoConNombre(node);
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
         /*Imprimimos Id*/
        //for(int i = 0; i < cogeValor(node);i++)
          //  System.out.print(tab);
        System.out.print(node.getId());

        if(node.getAsterisco() != null)
        {
            node.getAsterisco().apply(this);
        }
        /*Imprimimos '*' */
        System.out.print(node.getAsterisco());
    
        outAPtrOtroTipoConNombre(node);
    }

    public void inABasicoTipoVariable(ABasicoTipoVariable node)
    {
        defaultIn(node);
    }

    public void outABasicoTipoVariable(ABasicoTipoVariable node)
    {
        defaultOut(node);
    }

    public void caseABasicoTipoVariable(ABasicoTipoVariable node)
    {
        inABasicoTipoVariable(node);
        if(node.getTipoConNombre() != null)
        {
            ponValor(node.getTipoConNombre(), cogeValor(node));
            node.getTipoConNombre().apply(this);
        }
        outABasicoTipoVariable(node);
    }

    public void inARecordTipoVariable(ARecordTipoVariable node)
    {
        defaultIn(node);
    }

    public void outARecordTipoVariable(ARecordTipoVariable node)
    {
        defaultOut(node);
    }

    public void caseARecordTipoVariable(ARecordTipoVariable node)
    {
        inARecordTipoVariable(node);
        if(node.getTipoRecord() != null)
        {
            ponValor(node.getTipoRecord(), cogeValor(node));
            node.getTipoRecord().apply(this);
        }
        outARecordTipoVariable(node);
    }

    public void inAArrayTipoVariable(AArrayTipoVariable node)
    {
        defaultIn(node);
    }

    public void outAArrayTipoVariable(AArrayTipoVariable node)
    {
        defaultOut(node);
    }

    public void caseAArrayTipoVariable(AArrayTipoVariable node)
    {
        inAArrayTipoVariable(node);
        if(node.getArray() != null)
        {
            node.getArray().apply(this);
        }
        /*Imprimimos array*/
        //for (int i = 0; i < cogeValor(node); i++)
          //  System.out.print(tab);
        System.out.print(node.getArray());

        if(node.getACorch() != null)
        {
            node.getACorch().apply(this);
        }
        /*Imprimimos '[' */
        System.out.print(node.getACorch());

        if(node.getInd1() != null)
        {
            node.getInd1().apply(this);
        }
         /*Imprimimos Ind1 */
        System.out.print(node.getInd1());

        if(node.getPuntoPunto() != null)
        {
            node.getPuntoPunto().apply(this);
        }
        /*Imprimimos '..' */
        System.out.print(node.getPuntoPunto());
       
        if(node.getInd2() != null)
        {
            node.getInd2().apply(this);
        }
        /*Imprimimos Ind2 */
        System.out.print(node.getInd2());
        
        if(node.getCCorch() != null)
        {
            node.getCCorch().apply(this);
        }
        /*Imprimimos ']' */
        System.out.print(node.getCCorch());

       if(node.getOf() != null)
        {
            node.getOf().apply(this);
        }
        /*Imprimimos Of */
        System.out.print(node.getOf());

        if(node.getTipoConNombre() != null)
        {
            ponValor(node.getTipoConNombre(), cogeValor(node));
            node.getTipoConNombre().apply(this);
        }
        outAArrayTipoVariable(node);
    }

    public void inAArrayRecordTipoVariable(AArrayRecordTipoVariable node)
    {
        defaultIn(node);
    }

    public void outAArrayRecordTipoVariable(AArrayRecordTipoVariable node)
    {
        defaultOut(node);
    }

    public void caseAArrayRecordTipoVariable(AArrayRecordTipoVariable node)
    {
        inAArrayRecordTipoVariable(node);
        if(node.getArray() != null)
        {
            node.getArray().apply(this);
        }
        /*Imprimimos array*/
       // for (int i = 0; i < cogeValor(node); i++)
         //   System.out.print(tab);
        System.out.print(node.getArray());
        ponTabRecord(node.getArray(), ((node.getArray()).toString()).length());

        if(node.getACorch() != null)
        {
            node.getACorch().apply(this);
        }
        /*Imprimimos '[' */
        System.out.print(node.getACorch());
        ponTabRecord(node.getACorch(), ((node.getACorch()).toString()).length());

        if(node.getInd1() != null)
        {
            node.getInd1().apply(this);
        }
         /*Imprimimos Ind1 */
        System.out.print(node.getInd1());
        ponTabRecord(node.getInd1(), ((node.getInd1()).toString()).length());

        if(node.getPuntoPunto() != null)
        {
            node.getPuntoPunto().apply(this);
        }
        /*Imprimimos '..' */
        System.out.print(node.getPuntoPunto());
        ponTabRecord(node.getPuntoPunto(), ((node.getPuntoPunto()).toString()).length());
       
        if(node.getInd2() != null)
        {
            node.getInd2().apply(this);
        }
        /*Imprimimos Ind2 */
        System.out.print(node.getInd2());
        ponTabRecord(node.getInd2(), ((node.getInd2()).toString()).length());
        
        if(node.getCCorch() != null)
        {
            node.getCCorch().apply(this);
        }
        /*Imprimimos ']' */
        System.out.print(node.getCCorch());
        ponTabRecord(node.getCCorch(), ((node.getCCorch()).toString()).length());

       if(node.getOf() != null)
        {
            node.getOf().apply(this);
        }
        /*Imprimimos Of */
        System.out.print(node.getOf());
        ponTabRecord(node.getOf(), ((node.getOf()).toString()).length());
        
        if(node.getTipoRecord() != null)
        {
            ponValor(node.getTipoRecord(), cogeValor(node) + ( cogeTabRecord(node.getArray()) + 
                                cogeTabRecord(node.getACorch()) + cogeTabRecord(node.getInd1()) + 
                                cogeTabRecord(node.getPuntoPunto()) + cogeTabRecord(node.getInd2())+
                                cogeTabRecord(node.getCCorch()) + cogeTabRecord(node.getOf()) )/4 );
            node.getTipoRecord().apply(this);
        }
        outAArrayRecordTipoVariable(node);
    }

    public void inARecordTipoRecord(ARecordTipoRecord node)
    {
        defaultIn(node);
    }

    public void outARecordTipoRecord(ARecordTipoRecord node)
    {
        defaultOut(node);
    }

    public void caseARecordTipoRecord(ARecordTipoRecord node)
    {
        inARecordTipoRecord(node);
        if(node.getRecord() != null)
        {
            node.getRecord().apply(this);            
        }
        /*Imprimimos record*/
        System.out.println(node.getRecord());

        {
            Object temp[] = node.getDecVars().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ponValor((PDecVars)temp[i], cogeValor(node) + 1); 
                ((PDecVars) temp[i]).apply(this);
            }
        }
        {
            Object temp[] = node.getDefFunc().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ponValor((PDefFunc)temp[i], cogeValor(node) + 1);
                ((PDefFunc) temp[i]).apply(this);
            }
        }
        if(node.getEnd() != null)
        {
            node.getEnd().apply(this);
        }
        /*Imprimimos end_record*/
        for (int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);  
        System.out.print(node.getEnd());

        outARecordTipoRecord(node);
    }

    public void inAPtrRecordTipoRecord(APtrRecordTipoRecord node)
    {
        defaultIn(node);
    }

    public void outAPtrRecordTipoRecord(APtrRecordTipoRecord node)
    {
        defaultOut(node);
    }

    public void caseAPtrRecordTipoRecord(APtrRecordTipoRecord node)
    {
        inAPtrRecordTipoRecord(node);
        if(node.getRecord() != null)
        {
            node.getRecord().apply(this);            
        }
        /*Imprimimos record*/
        System.out.println(node.getRecord());

        {
            Object temp[] = node.getDecVars().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ponValor((PDecVars)temp[i], cogeValor(node) + 1);
                ((PDecVars) temp[i]).apply(this);
            }
        }
        {
            Object temp[] = node.getDefFunc().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ponValor((PDefFunc)temp[i], cogeValor(node) + 1); 
                ((PDefFunc) temp[i]).apply(this);
            }
        }
        if(node.getEnd() != null)
        {
            node.getEnd().apply(this);
        }
        /*Imprimimos end_record*/
        for (int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);   
        System.out.print(node.getEnd());
        
        if(node.getAsterisco() != null)
        {
            node.getAsterisco().apply(this);
        }
        //Imprimimos '*' 
        System.out.print(node.getAsterisco());
        outAPtrRecordTipoRecord(node);
    }

    public void inAUnoListId(AUnoListId node)
    {
        defaultIn(node);
    }

    public void outAUnoListId(AUnoListId node)
    {
        defaultOut(node);
    }

    public void caseAUnoListId(AUnoListId node)
    {
        inAUnoListId(node);
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        /*Imprimimos Id*/
        for(int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getId());
        
        ponTabRecord(node, ((node.getId()).toString()).length());

        outAUnoListId(node);
    }

    public void inAVariosListId(AVariosListId node)
    {
        defaultIn(node);
    }

    public void outAVariosListId(AVariosListId node)
    {
        defaultOut(node);
    }

    public void caseAVariosListId(AVariosListId node)
    {
        inAVariosListId(node);
        if(node.getListId() != null)
        {   
            ponTabRecord(node.getListId(), 0);        
            ponValor(node.getListId(), cogeValor(node));
            node.getListId().apply(this);
        }
        ponTabRecord(node, cogeTabRecord(node.getListId()));

        if(node.getComa() != null)
        {
            node.getComa().apply(this);
        }
        /*Imprimimos ','*/
        System.out.print(node.getComa());
        
        ponTabRecord(node, cogeTabRecord(node) + ((node.getComa()).toString()).length());

        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        /*Imprimimos Id*/
        System.out.print(node.getId());
        
        ponTabRecord(node, cogeTabRecord(node) + ((node.getId()).toString()).length());

        outAVariosListId(node);
    }

    public void inAUnoListParmFunc(AUnoListParmFunc node)
    {
        defaultIn(node);
    }

    public void outAUnoListParmFunc(AUnoListParmFunc node)
    {
        defaultOut(node);
    }

    public void caseAUnoListParmFunc(AUnoListParmFunc node)
    {
        inAUnoListParmFunc(node);
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        System.out.print(node.getId()); //Imprimimos Id

        if(node.getDosPuntos() != null)
        {
            node.getDosPuntos().apply(this);
        }
        System.out.print(": "); //Imprimimos ':'
        
        if(node.getTipoConNombre() != null)
        {
            ponValor(node.getTipoConNombre(), cogeValor(node));
            node.getTipoConNombre().apply(this);
        }
        outAUnoListParmFunc(node);
    }

    public void inAVariosListParmFunc(AVariosListParmFunc node)
    {
        defaultIn(node);
    }

    public void outAVariosListParmFunc(AVariosListParmFunc node)
    {
        defaultOut(node);
    }

    public void caseAVariosListParmFunc(AVariosListParmFunc node)
    {
        inAVariosListParmFunc(node);
        if(node.getListParmFunc() != null)
        {
            node.getListParmFunc().apply(this);
        }
        if(node.getComa() != null)
        {
            node.getComa().apply(this);
        }
        System.out.print(node.getComa()); //imprimimos ','
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        System.out.print(node.getId()); //imprimimos id

        if(node.getDosPuntos() != null)
        {
            node.getDosPuntos().apply(this);
        }
        System.out.print(": "); //imprimimos ':'
        
        if(node.getTipoConNombre() != null)
        {
            ponValor(node.getTipoConNombre(), cogeValor(node));
            node.getTipoConNombre().apply(this);
        }

        outAVariosListParmFunc(node);
    }

    public void inAVaciaListParmFunc(AVaciaListParmFunc node)
    {
        defaultIn(node);
    }

    public void outAVaciaListParmFunc(AVaciaListParmFunc node)
    {
        defaultOut(node);
    }

    public void caseAVaciaListParmFunc(AVaciaListParmFunc node)
    {
        inAVaciaListParmFunc(node);
        outAVaciaListParmFunc(node);
    }

    public void inADefFunc(ADefFunc node)
    {
        defaultIn(node);
    }

    public void outADefFunc(ADefFunc node)
    {
        defaultOut(node);
    }

    public void caseADefFunc(ADefFunc node)
    {
        inADefFunc(node);
        if(node.getFunction() != null)
        {
            node.getFunction().apply(this);
        }
        for (int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getFunction()); //imprimimos function

        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        System.out.print(node.getId()); //imprimimos id

        if(node.getAParen() != null)
        {
            node.getAParen().apply(this);
        }
        System.out.print(node.getAParen()); //imprimimos '('
        if(node.getListParmFunc() != null)
        {
            ponValor(node.getListParmFunc(), 0);
            node.getListParmFunc().apply(this);
        }
        if(node.getCParen() != null)
        {
            node.getCParen().apply(this);
        }
        System.out.print(node.getCParen()); //imprimimos ')'

        if(node.getDosPuntos() != null)
        {
            node.getDosPuntos().apply(this);
        }
        System.out.print(": "); //imprimimos ':'

        if(node.getTipoConNombre() != null)
        {
            ponValor(node.getListParmFunc(),cogeValor(node));
            node.getTipoConNombre().apply(this);
        }

        if(node.getPyc() != null)
        {
            node.getPyc().apply(this);
        }
        System.out.println(node.getPyc()); //imprimimos ';'

        {
            Object temp[] = node.getDecVars().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ponValor((PDecVars)temp[i], cogeValor(node) + 1);
                ((PDecVars) temp[i]).apply(this);
            }
        }
        {
            Object temp[] = node.getDefFunc().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ponValor((PDefFunc)temp[i], cogeValor(node) + 1);
                ((PDefFunc) temp[i]).apply(this);
            }
        }
        if(node.getGrupoSent() != null)
        {
            ponValor(node.getGrupoSent(), cogeValor(node) + 1);
            node.getGrupoSent().apply(this);
        }
        if(node.getEndFunction() != null)
        {
            node.getEndFunction().apply(this);
        }
        for (int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.println(node.getEndFunction());//imprimimos end_function
        outADefFunc(node);
    }

    public void inAGrupoSent(AGrupoSent node)
    {
        defaultIn(node);
    }

    public void outAGrupoSent(AGrupoSent node)
    {
        defaultOut(node);
    }

    public void caseAGrupoSent(AGrupoSent node)
    {
        inAGrupoSent(node);
        {
            Object temp[] = node.getUnaSent().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ponValor((PUnaSent)temp[i], cogeValor(node));
                ((PUnaSent) temp[i]).apply(this);
            }
        }
        outAGrupoSent(node);
    }

    public void inASentUnaSent(ASentUnaSent node)
    {
        defaultIn(node);
    }

    public void outASentUnaSent(ASentUnaSent node)
    {
        defaultOut(node);
    }

    public void caseASentUnaSent(ASentUnaSent node)
    {
        inASentUnaSent(node);
        if(node.getSent() != null)
        {
            ponValor(node.getSent(), cogeValor(node));
            node.getSent().apply(this);
        }
        outASentUnaSent(node);
    }

    public void inASentConfUnaSent(ASentConfUnaSent node)
    {
        defaultIn(node);
    }

    public void outASentConfUnaSent(ASentConfUnaSent node)
    {
        defaultOut(node);
    }

    public void caseASentConfUnaSent(ASentConfUnaSent node)
    {
        inASentConfUnaSent(node);
        if(node.getSentConflictiva() != null)
        {
            ponValor(node.getSentConflictiva(), cogeValor(node));
            node.getSentConflictiva().apply(this);
        }
        outASentConfUnaSent(node);
    }

    public void inASentWhileIfSentConflictiva(ASentWhileIfSentConflictiva node)
    {
        defaultIn(node);
    }

    public void outASentWhileIfSentConflictiva(ASentWhileIfSentConflictiva node)
    {
        defaultOut(node);
    }

    public void caseASentWhileIfSentConflictiva(ASentWhileIfSentConflictiva node)
    {
        inASentWhileIfSentConflictiva(node);
        if(node.getWhile() != null)
        {
            node.getWhile().apply(this);
        }
        //Imprimimos while
        for (int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getWhile());

        if(node.getExpr() != null)
        {
            ponValor(node.getExpr(), 0);
            node.getExpr().apply(this);
        }

        if(node.getDo() != null)
        {
            node.getDo().apply(this);
        }
        System.out.println(node.getDo()); //imprimimos do

        if(node.getSentIf() != null)
        {
            ponValor(node.getSentIf(), cogeValor(node) + 1);
            node.getSentIf().apply(this);
        }
        outASentWhileIfSentConflictiva(node);
    }

    public void inASentBeginSentConflictiva(ASentBeginSentConflictiva node)
    {
        defaultIn(node);
    }

    public void outASentBeginSentConflictiva(ASentBeginSentConflictiva node)
    {
        defaultOut(node);
    }

    public void caseASentBeginSentConflictiva(ASentBeginSentConflictiva node)
    {
        inASentBeginSentConflictiva(node);
        if(node.getBegin() != null)
        {
            node.getBegin().apply(this);
        }
        //Imprimimos begin
        for (int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.println(node.getBegin());

        {
            Object temp[] = node.getDecVars().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ponValor((PDecVars) temp[i], cogeValor(node) + 1);
                ((PDecVars) temp[i]).apply(this);
            }
        }
        if(node.getGrupoSent() != null)
        {
            ponValor(node.getGrupoSent(), cogeValor(node) + 1);
            node.getGrupoSent().apply(this);
        }
        if(node.getEnd() != null)
        {
            node.getEnd().apply(this);
        }
        //Imprimimos end
        for (int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.println(node.getEnd());

        outASentBeginSentConflictiva(node);
    }

    public void inASentIfSentConflictiva(ASentIfSentConflictiva node)
    {
        defaultIn(node);
    }

    public void outASentIfSentConflictiva(ASentIfSentConflictiva node)
    {
        defaultOut(node);
    }

    public void caseASentIfSentConflictiva(ASentIfSentConflictiva node)
    {
        inASentIfSentConflictiva(node);
        if(node.getSentIf() != null)
        {
            ponValor(node.getSentIf(), cogeValor(node));
            node.getSentIf().apply(this);
        }
        outASentIfSentConflictiva(node);
    }

    public void inAIfEmparejadoSentIf(AIfEmparejadoSentIf node)
    {
        defaultIn(node);
    }

    public void outAIfEmparejadoSentIf(AIfEmparejadoSentIf node)
    {
        defaultOut(node);
    }

    public void caseAIfEmparejadoSentIf(AIfEmparejadoSentIf node)
    {
        inAIfEmparejadoSentIf(node);
        if(node.getIfEmparejado() != null)
        {
            ponValor(node.getIfEmparejado(), cogeValor(node));
            node.getIfEmparejado().apply(this);
        }
        outAIfEmparejadoSentIf(node);
    }

    public void inAIfNoEmparejadoSentIf(AIfNoEmparejadoSentIf node)
    {
        defaultIn(node);
    }

    public void outAIfNoEmparejadoSentIf(AIfNoEmparejadoSentIf node)
    {
        defaultOut(node);
    }

    public void caseAIfNoEmparejadoSentIf(AIfNoEmparejadoSentIf node)
    {
        inAIfNoEmparejadoSentIf(node);
        if(node.getIfNoEmparejado() != null)
        {
            ponValor(node.getIfNoEmparejado(), cogeValor(node));
            node.getIfNoEmparejado().apply(this);
        }
        outAIfNoEmparejadoSentIf(node);
    }

    public void inAIfEmparejado(AIfEmparejado node)
    {
        defaultIn(node);
    }

    public void outAIfEmparejado(AIfEmparejado node)
    {
        defaultOut(node);
    }

    public void caseAIfEmparejado(AIfEmparejado node)
    {
        inAIfEmparejado(node);
        if(node.getIf() != null)
        {            
            node.getIf().apply(this);            
        }
        //Imprimimos if
        for (int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getIf());
       

        if(node.getExpr() != null)
        {
            ponValor(node.getExpr(), 0);
            node.getExpr().apply(this);
        }

        if(node.getThen() != null)
        {
            node.getThen().apply(this);
        }
        System.out.println(node.getThen()); //imprimimos then

        if(node.getC1() != null)
        {
            ponValor(node.getC1(), cogeValor(node) + 1);
            node.getC1().apply(this);
        }
        if(node.getElse() != null)
        {
            node.getElse().apply(this);
        }
         //Imprimimos else
        for (int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.println(node.getElse());
 
        if(node.getC2() != null)
        {
            ponValor(node.getC2(), cogeValor(node) + 1);
            node.getC2().apply(this);
        }
        outAIfEmparejado(node);
    }

    public void inAIfEmpCuerpoIfEmparejado(AIfEmpCuerpoIfEmparejado node)
    {
        defaultIn(node);
    }

    public void outAIfEmpCuerpoIfEmparejado(AIfEmpCuerpoIfEmparejado node)
    {
        defaultOut(node);
    }

    public void caseAIfEmpCuerpoIfEmparejado(AIfEmpCuerpoIfEmparejado node)
    {
        inAIfEmpCuerpoIfEmparejado(node);
        if(node.getIfEmparejado() != null)
        {
            ponValor(node.getIfEmparejado(), cogeValor(node));
            node.getIfEmparejado().apply(this);
        }
        outAIfEmpCuerpoIfEmparejado(node);
    }

    public void inABloqueCuerpoIfEmparejado(ABloqueCuerpoIfEmparejado node)
    {
        defaultIn(node);
    }

    public void outABloqueCuerpoIfEmparejado(ABloqueCuerpoIfEmparejado node)
    {
        defaultOut(node);
    }

    public void caseABloqueCuerpoIfEmparejado(ABloqueCuerpoIfEmparejado node)
    {
        inABloqueCuerpoIfEmparejado(node);
        if(node.getBloque() != null)
        {
            ponValor(node.getBloque(), cogeValor(node));
            node.getBloque().apply(this);
        }
        outABloqueCuerpoIfEmparejado(node);
    }

    public void inAWhileIfCuerpoIfEmparejado(AWhileIfCuerpoIfEmparejado node)
    {
        defaultIn(node);
    }

    public void outAWhileIfCuerpoIfEmparejado(AWhileIfCuerpoIfEmparejado node)
    {
        defaultOut(node);
    }

    public void caseAWhileIfCuerpoIfEmparejado(AWhileIfCuerpoIfEmparejado node)
    {
        inAWhileIfCuerpoIfEmparejado(node);
       
         if(node.getWhile() != null)
        {
            node.getWhile().apply(this);
        }
        //Imprimimos while
        for (int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getWhile());

        if(node.getExpr() != null)
        {
            ponValor(node.getExpr(), 0);
            node.getExpr().apply(this);
        }

        if(node.getDo() != null)
        {
            node.getDo().apply(this);
        }
        System.out.println(node.getDo()); //imprimimos do

        if(node.getIfEmparejado() != null)
        {
            ponValor(node.getIfEmparejado(), cogeValor(node) + 1);        
            node.getIfEmparejado().apply(this);
        }
        outAWhileIfCuerpoIfEmparejado(node);
    }

    public void inAIfSimpBlIfNoEmparejado(AIfSimpBlIfNoEmparejado node)
    {
        defaultIn(node);
    }

    public void outAIfSimpBlIfNoEmparejado(AIfSimpBlIfNoEmparejado node)
    {
        defaultOut(node);
    }

    public void caseAIfSimpBlIfNoEmparejado(AIfSimpBlIfNoEmparejado node)
    {
        inAIfSimpBlIfNoEmparejado(node);
        if(node.getIf() != null)
        {            
            node.getIf().apply(this);            
        }
        //Imprimimos if
        for (int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getIf());
       

        if(node.getExpr() != null)
        {
            ponValor(node.getExpr(), 0);
            node.getExpr().apply(this);
        }

        if(node.getThen() != null)
        {
            node.getThen().apply(this);
        }
        System.out.println(node.getThen()); //imprimimos then

        if(node.getBloque() != null)
        {
            ponValor(node.getBloque(), cogeValor(node) + 1);
            node.getBloque().apply(this);
        }
        outAIfSimpBlIfNoEmparejado(node);
    }

    public void inAIfSimpIfIfNoEmparejado(AIfSimpIfIfNoEmparejado node)
    {
        defaultIn(node);
    }

    public void outAIfSimpIfIfNoEmparejado(AIfSimpIfIfNoEmparejado node)
    {
        defaultOut(node);
    }

    public void caseAIfSimpIfIfNoEmparejado(AIfSimpIfIfNoEmparejado node)
    {
        inAIfSimpIfIfNoEmparejado(node);
         if(node.getIf() != null)
        {            
            node.getIf().apply(this);            
        }
        //Imprimimos if
        for (int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getIf());
       

        if(node.getExpr() != null)
        {
            ponValor(node.getExpr(), 0);
            node.getExpr().apply(this);
        }

        if(node.getThen() != null)
        {
            node.getThen().apply(this);
        }
        System.out.println(node.getThen()); //imprimimos then

        if(node.getSentIf() != null)
        {
            ponValor(node.getSentIf(), cogeValor(node) + 1);
            node.getSentIf().apply(this);
        }
        outAIfSimpIfIfNoEmparejado(node);
    }

    public void inAIfSimpWhileIfIfNoEmparejado(AIfSimpWhileIfIfNoEmparejado node)
    {
        defaultIn(node);
    }

    public void outAIfSimpWhileIfIfNoEmparejado(AIfSimpWhileIfIfNoEmparejado node)
    {
        defaultOut(node);
    }

    public void caseAIfSimpWhileIfIfNoEmparejado(AIfSimpWhileIfIfNoEmparejado node)
    {
        inAIfSimpWhileIfIfNoEmparejado(node);
         if(node.getIf() != null)
        {            
            node.getIf().apply(this);            
        }
        //Imprimimos if
        for (int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getIf());
       

        if(node.getE1() != null)
        {
            ponValor(node.getE1(), 0);
            node.getE1().apply(this);
        }

        if(node.getThen() != null)
        {
            node.getThen().apply(this);
        }
        System.out.println(node.getThen()); //imprimimos then

        if(node.getWhile() != null)
        {
            node.getWhile().apply(this);
        }
        //imprimimos While
        for (int i = 0; i < cogeValor(node) + 1 ; i++)
            System.out.print(tab);
        System.out.print(node.getWhile());

        if(node.getE2() != null)
        {
            ponValor(node.getE2(), 0);
            node.getE2().apply(this);
        }
        if(node.getDo() != null)
        {
            node.getDo().apply(this);
        }
        System.out.println(node.getDo()); //imprimimos Do

        if(node.getSentIf() != null)
        {
            ponValor(node.getSentIf(), cogeValor(node) + 2);
            node.getSentIf().apply(this);
        }
        outAIfSimpWhileIfIfNoEmparejado(node);
    }

    public void inAIfCompIfNoEmparejado(AIfCompIfNoEmparejado node)
    {
        defaultIn(node);
    }

    public void outAIfCompIfNoEmparejado(AIfCompIfNoEmparejado node)
    {
        defaultOut(node);
    }

    public void caseAIfCompIfNoEmparejado(AIfCompIfNoEmparejado node)
    {
        inAIfCompIfNoEmparejado(node);
          if(node.getIf() != null)
        {            
            node.getIf().apply(this);            
        }
        //Imprimimos if
        for (int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getIf());
       

        if(node.getExpr() != null)
        {
            ponValor(node.getExpr(), 0);
            node.getExpr().apply(this);
        }

        if(node.getThen() != null)
        {
            node.getThen().apply(this);
        }
        System.out.println(node.getThen()); //imprimimos then
        
        if(node.getCuerpoIfEmparejado() != null)
        {
            ponValor(node.getCuerpoIfEmparejado(), cogeValor(node) + 1);
            node.getCuerpoIfEmparejado().apply(this);
        }
        if(node.getElse() != null)
        {
            node.getElse().apply(this);
        }
        //Imprimimos else
        for (int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.println(node.getElse());

        if(node.getIfNoEmparejado() != null)
        {
            ponValor(node.getIfNoEmparejado(), cogeValor(node) + 1);
            node.getIfNoEmparejado().apply(this);
        }
        outAIfCompIfNoEmparejado(node);
    }

    public void inAIfCompWhileIfNoEmparejado(AIfCompWhileIfNoEmparejado node)
    {
        defaultIn(node);
    }

    public void outAIfCompWhileIfNoEmparejado(AIfCompWhileIfNoEmparejado node)
    {
        defaultOut(node);
    }

    public void caseAIfCompWhileIfNoEmparejado(AIfCompWhileIfNoEmparejado node)
    {
        inAIfCompWhileIfNoEmparejado(node);
           if(node.getIf() != null)
        {            
            node.getIf().apply(this);            
        }
        //Imprimimos if
        for (int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getIf());
       

        if(node.getE1() != null)
        {
            ponValor(node.getE1(), 0);
            node.getE1().apply(this);
        }

        if(node.getThen() != null)
        {
            node.getThen().apply(this);
        }
        System.out.println(node.getThen()); //imprimimos then

        if(node.getCuerpoIfEmparejado() != null)
        {
            ponValor(node.getCuerpoIfEmparejado(), cogeValor(node) + 1);
            node.getCuerpoIfEmparejado().apply(this);
        }

        if(node.getElse() != null)
        {
            node.getElse().apply(this);
        }
        //Imprimimos else
        for (int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.println(node.getElse());

        if(node.getWhile() != null)
        {
            node.getWhile().apply(this);
        }
        //Imprimimos while
        for (int i = 0; i < cogeValor(node) + 1; i++)
            System.out.print(tab);
        System.out.print(node.getWhile());

       if(node.getE2() != null)
        {
            ponValor(node.getE2(), 0);
            node.getE2().apply(this);
        }
        if(node.getDo() != null)
        {
            node.getDo().apply(this);
        }
        System.out.println(node.getDo()); //imprimimos do
    
        if(node.getIfNoEmparejado() != null)
        {
            ponValor(node.getIfNoEmparejado(), cogeValor(node) + 2);
            node.getIfNoEmparejado().apply(this);
        }
        outAIfCompWhileIfNoEmparejado(node);
    }

    public void inAUnoBloque(AUnoBloque node)
    {
        defaultIn(node);
    }

    public void outAUnoBloque(AUnoBloque node)
    {
        defaultOut(node);
    }

    public void caseAUnoBloque(AUnoBloque node)
    {
        inAUnoBloque(node);
        if(node.getSent() != null)
        {
            ponValor(node.getSent(), cogeValor(node));
            node.getSent().apply(this);
        }
        outAUnoBloque(node);
    }

    public void inAVariosBloque(AVariosBloque node)
    {
        defaultIn(node);
    }

    public void outAVariosBloque(AVariosBloque node)
    {
        defaultOut(node);
    }

    public void caseAVariosBloque(AVariosBloque node)
    {
        inAVariosBloque(node);
        if(node.getBegin() != null)
        {
            node.getBegin().apply(this);
        }
        //imprimimos begin
        for (int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.println(node.getBegin());
        
        {
            Object temp[] = node.getDecVars().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ponValor((PDecVars) temp[i], cogeValor(node) + 1);
                ((PDecVars) temp[i]).apply(this);
            }
        }
        if(node.getGrupoSent() != null)
        {
            ponValor(node.getGrupoSent(), cogeValor(node) + 1);
            node.getGrupoSent().apply(this);
        }
        if(node.getEnd() != null)
        {
            node.getEnd().apply(this);
        }
        //imprimimos end
        for (int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.println(node.getEnd());
        outAVariosBloque(node);
    }

    public void inAAsigEstaticaSent(AAsigEstaticaSent node)
    {
        defaultIn(node);
    }

    public void outAAsigEstaticaSent(AAsigEstaticaSent node)
    {
        defaultOut(node);
    }

    public void caseAAsigEstaticaSent(AAsigEstaticaSent node)
    {
        inAAsigEstaticaSent(node);
        if(node.getExprUnaria() != null)
        {
            ponValor(node.getExprUnaria(), cogeValor(node));
            node.getExprUnaria().apply(this);
        }
        if(node.getOpAsig() != null)
        {
            node.getOpAsig().apply(this);
        }
        System.out.print(node.getOpAsig()); //imprimimos ':='
        if(node.getExpr() != null)
        {
            ponValor(node.getExpr(), 0);
            node.getExpr().apply(this);
        }
        if(node.getPyc() != null)
        {
            node.getPyc().apply(this);
        }
        System.out.println(node.getPyc()); //imprimimos ';'
        outAAsigEstaticaSent(node);
    }

    public void inAAsigMemDinUnoSent(AAsigMemDinUnoSent node)
    {
        defaultIn(node);
    }

    public void outAAsigMemDinUnoSent(AAsigMemDinUnoSent node)
    {
        defaultOut(node);
    }

    public void caseAAsigMemDinUnoSent(AAsigMemDinUnoSent node)
    {
        inAAsigMemDinUnoSent(node);
         if(node.getExprUnaria() != null)
        {
            ponValor(node.getExprUnaria(), cogeValor(node));
            node.getExprUnaria().apply(this);
        }
        if(node.getOpAsig() != null)
        {
            node.getOpAsig().apply(this);
        }
        System.out.print(node.getOpAsig()); //imprimimos ':='
        
        if(node.getNew() != null)
        {
            node.getNew().apply(this);
        }
        System.out.print(node.getNew());    //imprimimos new
    
        if(node.getTipoConNombre() != null)
        {
            ponValor(node.getTipoConNombre(), 0);
            node.getTipoConNombre().apply(this);
        }
        if(node.getPyc() != null)
        {
            node.getPyc().apply(this);
        }
        System.out.println(node.getPyc()); //imprimimos ';'
        outAAsigMemDinUnoSent(node);
    }

    public void inAAsigMemDinVariosSent(AAsigMemDinVariosSent node)
    {
        defaultIn(node);
    }

    public void outAAsigMemDinVariosSent(AAsigMemDinVariosSent node)
    {
        defaultOut(node);
    }

    public void caseAAsigMemDinVariosSent(AAsigMemDinVariosSent node)
    {
        inAAsigMemDinVariosSent(node);
        if(node.getExprUnaria() != null)
        {
            ponValor(node.getExprUnaria(), cogeValor(node));
            node.getExprUnaria().apply(this);
        }
        if(node.getOpAsig() != null)
        {
            node.getOpAsig().apply(this);
        }
        System.out.print(node.getOpAsig()); //imprimimos ':='
        
        if(node.getNew() != null)
        {
            node.getNew().apply(this);
        }
        System.out.print(node.getNew());    //imprimimos new
    
        if(node.getTipoConNombre() != null)
        {
            ponValor(node.getTipoConNombre(), 0);
            node.getTipoConNombre().apply(this);
        }
        
        if(node.getACorch() != null)
        {
            node.getACorch().apply(this);
        }
        System.out.print(node.getACorch());    //imprimimos '['

        if(node.getExpr() != null)
        {
            ponValor(node.getExpr(), 0);
            node.getExpr().apply(this);
        }

        if(node.getCCorch() != null)
        {
            node.getCCorch().apply(this);
        }
        System.out.print(node.getCCorch());    //imprimimos ']'

        if(node.getPyc() != null)
        {
            node.getPyc().apply(this);
        }
        System.out.println(node.getPyc()); //imprimimos ';'
        outAAsigMemDinVariosSent(node);
    }

    public void inALiberarMemoriaSent(ALiberarMemoriaSent node)
    {
        defaultIn(node);
    }

    public void outALiberarMemoriaSent(ALiberarMemoriaSent node)
    {
        defaultOut(node);
    }

    public void caseALiberarMemoriaSent(ALiberarMemoriaSent node)
    {
        inALiberarMemoriaSent(node);
        if(node.getDelete() != null)
        {
            node.getDelete().apply(this);
        }
        //Imprimimos delete
        for(int i = 0 ; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getDelete());

        if(node.getExprUnaria() != null)
        {
            ponValor(node.getExprUnaria(), 0);
            node.getExprUnaria().apply(this);
        }
        if(node.getPyc() != null)
        {
            node.getPyc().apply(this);
        }
        System.out.println(node.getPyc()); //imprimimos ';'
        outALiberarMemoriaSent(node);
    }

    public void inAReturnSent(AReturnSent node)
    {
        defaultIn(node);
    }

    public void outAReturnSent(AReturnSent node)
    {
        defaultOut(node);
    }

    public void caseAReturnSent(AReturnSent node)
    {
        inAReturnSent(node);
        if(node.getReturn() != null)
        {
            node.getReturn().apply(this);
        }
        /*Imprimimos return*/
        for(int i = 0 ; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getReturn());

        if(node.getExpr() != null)
        {
            ponValor(node.getExpr(), 0);
            node.getExpr().apply(this);
        }
        if(node.getPyc() != null)
        {
            node.getPyc().apply(this);
        }
        System.out.println(node.getPyc()); //imprimimos ';'
        outAReturnSent(node);
    }

    public void inAPrintCadSent(APrintCadSent node)
    {
        defaultIn(node);
    }

    public void outAPrintCadSent(APrintCadSent node)
    {
        defaultOut(node);
    }

    public void caseAPrintCadSent(APrintCadSent node)
    {
        inAPrintCadSent(node);
        if(node.getPrint() != null)
        {
            node.getPrint().apply(this);
        }
        /*Imprimimos print*/
        for(int i = 0 ; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getPrint());

       if(node.getCadena() != null)
        {
            node.getCadena().apply(this);
        }
        System.out.print(node.getCadena());

        if(node.getPyc() != null)
        {
            node.getPyc().apply(this);
        }
        System.out.println(node.getPyc()); //imprimimos ';'
        outAPrintCadSent(node);
    }

    public void inAPrintExpSent(APrintExpSent node)
    {
        defaultIn(node);
    }

    public void outAPrintExpSent(APrintExpSent node)
    {
        defaultOut(node);
    }

    public void caseAPrintExpSent(APrintExpSent node)
    {
        inAPrintExpSent(node);
        if(node.getPrint() != null)
        {
            node.getPrint().apply(this);
        }
        /*Imprimimos print*/
        for(int i = 0 ; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getPrint());

        if(node.getListExpr() != null)
        {
            ponValor(node.getListExpr(),0);
            node.getListExpr().apply(this);
        }
        if(node.getPyc() != null)
        {
            node.getPyc().apply(this);
        }
        System.out.println(node.getPyc()); //imprimimos ';'
        outAPrintExpSent(node);
    }

    public void inAContinueSent(AContinueSent node)
    {
        defaultIn(node);
    }

    public void outAContinueSent(AContinueSent node)
    {
        defaultOut(node);
    }

    public void caseAContinueSent(AContinueSent node)
    {
        inAContinueSent(node);
        if(node.getContinue() != null)
        {
            node.getContinue().apply(this);
        }
        /*Imprimimos continue*/
        for(int i = 0 ; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getContinue());

        if(node.getPyc() != null)
        {
            node.getPyc().apply(this);
        }
        System.out.println(node.getPyc()); //imprimimos ';'
        outAContinueSent(node);
    }

    public void inABreakSent(ABreakSent node)
    {
        defaultIn(node);
    }

    public void outABreakSent(ABreakSent node)
    {
        defaultOut(node);
    }

    public void caseABreakSent(ABreakSent node)
    {
        inABreakSent(node);
        if(node.getBreak() != null)
        {
            node.getBreak().apply(this);
        }
        /*Imprimimos break*/
        for(int i = 0 ; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getBreak());

        if(node.getPyc() != null)
        {
            node.getPyc().apply(this);
        }
        System.out.println(node.getPyc()); //imprimimos ';'
        outABreakSent(node);
    }

    public void inAWhileSent(AWhileSent node)
    {
        defaultIn(node);
    }

    public void outAWhileSent(AWhileSent node)
    {
        defaultOut(node);
    }

    public void caseAWhileSent(AWhileSent node)
    {
        inAWhileSent(node);
        if(node.getWhile() != null)
        {
            node.getWhile().apply(this);
        }
        /*Imprimimos while*/
        for(int i = 0 ; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getWhile());
       
        if(node.getExpr() != null)
        {
            ponValor(node.getExpr(),0);
            node.getExpr().apply(this);
        }
        if(node.getDo() != null)
        {
            node.getDo().apply(this);
        }
        System.out.println(node.getDo()); //Imprimimos do

        if(node.getBloque() != null)
        {
            ponValor(node.getBloque(), cogeValor(node) + 1);
            node.getBloque().apply(this);
        }
        outAWhileSent(node);
    }

    public void inAWithSent(AWithSent node)
    {
        defaultIn(node);
    }

    public void outAWithSent(AWithSent node)
    {
        defaultOut(node);
    }

    public void caseAWithSent(AWithSent node)
    {
        inAWithSent(node);
        if(node.getWith() != null)
        {
            node.getWith().apply(this);
        }
        /*Imprimimos with*/
        for(int i = 0 ; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getWith());
 
        if(node.getExprUnaria() != null)
        {
            ponValor(node.getExprUnaria(), 0);
            node.getExprUnaria().apply(this);
        }
        if(node.getDo() != null)
        {
            node.getDo().apply(this);
        }
        System.out.println(node.getDo()); //Imprimimos do

        if(node.getGrupoSent() != null)
        {
            ponValor(node.getGrupoSent(), cogeValor(node) + 1);
            node.getGrupoSent().apply(this);
        }
        if(node.getEnd() != null)
        {
            node.getEnd().apply(this);
        }
        System.out.println(node.getEnd()); //Imprimimos end
        
        outAWithSent(node);
    }

    public void inAUnoListExpr(AUnoListExpr node)
    {
        defaultIn(node);
    }

    public void outAUnoListExpr(AUnoListExpr node)
    {
        defaultOut(node);
    }

    public void caseAUnoListExpr(AUnoListExpr node)
    {
        inAUnoListExpr(node);
        if(node.getExpr() != null)
        {
            ponValor(node.getExpr(), cogeValor(node));
            node.getExpr().apply(this);
        }
        outAUnoListExpr(node);
    }

    public void inAVariosListExpr(AVariosListExpr node)
    {
        defaultIn(node);
    }

    public void outAVariosListExpr(AVariosListExpr node)
    {
        defaultOut(node);
    }

    public void caseAVariosListExpr(AVariosListExpr node)
    {
        inAVariosListExpr(node);
        if(node.getListExpr() != null)
        {
            ponValor(node.getListExpr(), cogeValor(node));
            node.getListExpr().apply(this);
        }
        if(node.getComa() != null)
        {
            node.getComa().apply(this);
        }
        System.out.print(node.getComa()); //imprimimos ','

        if(node.getExpr() != null)
        {
            ponValor(node.getExpr(), 0);
            node.getExpr().apply(this);
        }
        outAVariosListExpr(node);
    }

    public void inAVaciaListExpr(AVaciaListExpr node)
    {
        defaultIn(node);
    }

    public void outAVaciaListExpr(AVaciaListExpr node)
    {
        defaultOut(node);
    }

    public void caseAVaciaListExpr(AVaciaListExpr node)
    {
        inAVaciaListExpr(node);
        outAVaciaListExpr(node);
    }

    public void inAArrayExprPrimaria(AArrayExprPrimaria node)
    {
        defaultIn(node);
    }

    public void outAArrayExprPrimaria(AArrayExprPrimaria node)
    {
        defaultOut(node);
    }

    public void caseAArrayExprPrimaria(AArrayExprPrimaria node)
    {
        inAArrayExprPrimaria(node);
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        //Imprimimos id
        for (int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getId());

        if(node.getACorch() != null)
        {
            node.getACorch().apply(this);
        }
        System.out.print(node.getACorch()); //Imprimimos '['

        if(node.getExpr() != null)
        {   
            ponValor(node.getExpr(), 0 );
            node.getExpr().apply(this);
        }
        if(node.getCCorch() != null)
        {
            node.getCCorch().apply(this);
        }
        System.out.print(node.getCCorch()); //Imprimimos ']'

        outAArrayExprPrimaria(node);
    }

    public void inARecordIdExprPrimaria(ARecordIdExprPrimaria node)
    {
        defaultIn(node);
    }

    public void outARecordIdExprPrimaria(ARecordIdExprPrimaria node)
    {
        defaultOut(node);
    }

    public void caseARecordIdExprPrimaria(ARecordIdExprPrimaria node)
    {
        inARecordIdExprPrimaria(node);
        if(node.getExprPrimaria() != null)
        {
            ponValor(node.getExprPrimaria(), cogeValor(node));
            node.getExprPrimaria().apply(this);
        }
        
        if(node.getPunto() != null)
        {
            node.getPunto().apply(this);
        }
        System.out.print(node.getPunto()); //Imprimimos '.'

        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        System.out.print(node.getId()); //Imprimimos id

        outARecordIdExprPrimaria(node);
    }

    public void inARecordFuncExprPrimaria(ARecordFuncExprPrimaria node)
    {
        defaultIn(node);
    }

    public void outARecordFuncExprPrimaria(ARecordFuncExprPrimaria node)
    {
        defaultOut(node);
    }

    public void caseARecordFuncExprPrimaria(ARecordFuncExprPrimaria node)
    {
        inARecordFuncExprPrimaria(node);
         if(node.getExprPrimaria() != null)
        {
            ponValor(node.getExprPrimaria(), cogeValor(node));
            node.getExprPrimaria().apply(this);
        }
        
        if(node.getPunto() != null)
        {
            node.getPunto().apply(this);
        }
        System.out.print(node.getPunto()); //Imprimimos '.'

        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        System.out.print(node.getId()); //Imprimimos id
        
        if(node.getAParen() != null)
        {
            node.getAParen().apply(this);
        }
        System.out.print(node.getAParen()); //Imprimimos '('

        if(node.getListExpr() != null)
        {
            ponValor(node.getListExpr(), 0 );
            node.getListExpr().apply(this);
        }
        if(node.getCParen() != null)
        {
            node.getCParen().apply(this);
        }
        System.out.print(node.getCParen()); //Imprimimos ')'
        outARecordFuncExprPrimaria(node);
    }

    public void inARecordArrayExprPrimaria(ARecordArrayExprPrimaria node)
    {
        defaultIn(node);
    }

    public void outARecordArrayExprPrimaria(ARecordArrayExprPrimaria node)
    {
        defaultOut(node);
    }

    public void caseARecordArrayExprPrimaria(ARecordArrayExprPrimaria node)
    {
        inARecordArrayExprPrimaria(node);
          if(node.getExprPrimaria() != null)
        {
            ponValor(node.getExprPrimaria(), cogeValor(node));
            node.getExprPrimaria().apply(this);
        }
        
        if(node.getPunto() != null)
        {
            node.getPunto().apply(this);
        }
        System.out.print(node.getPunto()); //Imprimimos '.'

        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        System.out.print(node.getId()); //Imprimimos id
        
        if(node.getACorch() != null)
        {
            node.getACorch().apply(this);
        }
        System.out.print(node.getACorch()); //Imprimimos '['

        if(node.getExpr() != null)
        {
            ponValor(node.getExpr(), 0 );
            node.getExpr().apply(this);
        }
        if(node.getCCorch() != null)
        {
            node.getCCorch().apply(this);
        }
        System.out.print(node.getCCorch()); //Imprimimos ']'

        outARecordArrayExprPrimaria(node);
    }

    public void inALlamadaFuncExprPrimaria(ALlamadaFuncExprPrimaria node)
    {
        defaultIn(node);
    }

    public void outALlamadaFuncExprPrimaria(ALlamadaFuncExprPrimaria node)
    {
        defaultOut(node);
    }

    public void caseALlamadaFuncExprPrimaria(ALlamadaFuncExprPrimaria node)
    {
        inALlamadaFuncExprPrimaria(node);
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        for(int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getId()); //Imprimimos id
        if(node.getAParen() != null)
        {
            node.getAParen().apply(this);
        }
        System.out.print(node.getCParen()); //Imprimimos '('
        if(node.getListExpr() != null)
        {
            ponValor(node.getListExpr(), 0 );
            node.getListExpr().apply(this);
        }
        if(node.getCParen() != null)
        {
            node.getCParen().apply(this);
        }
        System.out.print(node.getCParen()); //Imprimimos ')'
        outALlamadaFuncExprPrimaria(node);
    }

    public void inANumeroExprPrimaria(ANumeroExprPrimaria node)
    {
        defaultIn(node);
    }

    public void outANumeroExprPrimaria(ANumeroExprPrimaria node)
    {
        defaultOut(node);
    }

    public void caseANumeroExprPrimaria(ANumeroExprPrimaria node)
    {
        inANumeroExprPrimaria(node);
        if(node.getNumero() != null)
        {
            node.getNumero().apply(this);
        }
        for(int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getNumero()); //Imprimimos numero

        outANumeroExprPrimaria(node);
    }

    public void inABooleanoExprPrimaria(ABooleanoExprPrimaria node)
    {
        defaultIn(node);
    }

    public void outABooleanoExprPrimaria(ABooleanoExprPrimaria node)
    {
        defaultOut(node);
    }

    public void caseABooleanoExprPrimaria(ABooleanoExprPrimaria node)
    {
        inABooleanoExprPrimaria(node);
        if(node.getBooleano() != null)
        {
            node.getBooleano().apply(this);
        }
        for(int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getBooleano()); //Imprimimos booleano

        outABooleanoExprPrimaria(node);
    }

    public void inAIdExprPrimaria(AIdExprPrimaria node)
    {
        defaultIn(node);
    }

    public void outAIdExprPrimaria(AIdExprPrimaria node)
    {
        defaultOut(node);
    }

    public void caseAIdExprPrimaria(AIdExprPrimaria node)
    {
        inAIdExprPrimaria(node);
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        for(int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getId()); //Imprimimos id

        outAIdExprPrimaria(node);
    }

    public void inASubexprExprPrimaria(ASubexprExprPrimaria node)
    {
        defaultIn(node);
    }

    public void outASubexprExprPrimaria(ASubexprExprPrimaria node)
    {
        defaultOut(node);
    }

    public void caseASubexprExprPrimaria(ASubexprExprPrimaria node)
    {
        inASubexprExprPrimaria(node);
        if(node.getAParen() != null)
        {
            node.getAParen().apply(this);
        }
        for(int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getAParen()); //Imprimimos '('

        if(node.getExpr() != null)
        {
            ponValor(node.getExpr(), 0);
            node.getExpr().apply(this);
        }
        if(node.getCParen() != null)
        {
            node.getCParen().apply(this);
        }
        System.out.print(node.getCParen()); //Imprimimos ')'

        outASubexprExprPrimaria(node);
    }

    public void inANegacionExprUnaria(ANegacionExprUnaria node)
    {
        defaultIn(node);
    }

    public void outANegacionExprUnaria(ANegacionExprUnaria node)
    {
        defaultOut(node);
    }

    public void caseANegacionExprUnaria(ANegacionExprUnaria node)
    {
        inANegacionExprUnaria(node);
        if(node.getSignExcl() != null)
        {
            node.getSignExcl().apply(this);
        }
        for(int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getSignExcl()); //Imprimimos '!'

        if(node.getExprUnaria() != null)
        {
            ponValor(node.getExprUnaria(), 0);
            node.getExprUnaria().apply(this);
        }
        outANegacionExprUnaria(node);
    }

    public void inADesreferenciaExprUnaria(ADesreferenciaExprUnaria node)
    {
        defaultIn(node);
    }

    public void outADesreferenciaExprUnaria(ADesreferenciaExprUnaria node)
    {
        defaultOut(node);
    }

    public void caseADesreferenciaExprUnaria(ADesreferenciaExprUnaria node)
    {
        inADesreferenciaExprUnaria(node);
        if(node.getAsterisco() != null)
        {
            node.getAsterisco().apply(this);
        }
        for(int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getAsterisco()); //Imprimimos '*'
  
       if(node.getExprUnaria() != null)
        {
            ponValor(node.getExprUnaria(), 0);
            node.getExprUnaria().apply(this);
        }
        outADesreferenciaExprUnaria(node);
    }

    public void inAReferenciaExprUnaria(AReferenciaExprUnaria node)
    {
        defaultIn(node);
    }

    public void outAReferenciaExprUnaria(AReferenciaExprUnaria node)
    {
        defaultOut(node);
    }

    public void caseAReferenciaExprUnaria(AReferenciaExprUnaria node)
    {
        inAReferenciaExprUnaria(node);
        if(node.getAmpersand() != null)
        {
            node.getAmpersand().apply(this);
        }
        for(int i  = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getAmpersand()); //Imprimimos '&'

        if(node.getExprUnaria() != null)
        {
            ponValor(node.getExprUnaria(), 0);
            node.getExprUnaria().apply(this);
        }
        outAReferenciaExprUnaria(node);
    }

    public void inAMenosExprUnaria(AMenosExprUnaria node)
    {
        defaultIn(node);
    }

    public void outAMenosExprUnaria(AMenosExprUnaria node)
    {
        defaultOut(node);
    }

    public void caseAMenosExprUnaria(AMenosExprUnaria node)
    {
        inAMenosExprUnaria(node);
        if(node.getMenos() != null)
        {
            node.getMenos().apply(this);
        }
        for(int i = 0; i < cogeValor(node); i++)
            System.out.print(tab);
        System.out.print(node.getMenos()); //Imprimimos '-'
 
        if(node.getExprUnaria() != null)
        {
            ponValor(node.getExprUnaria(), 0);
            node.getExprUnaria().apply(this);
        }
        outAMenosExprUnaria(node);
    }

    public void inAOtrosExprUnaria(AOtrosExprUnaria node)
    {
        defaultIn(node);
    }

    public void outAOtrosExprUnaria(AOtrosExprUnaria node)
    {
        defaultOut(node);
    }

    public void caseAOtrosExprUnaria(AOtrosExprUnaria node)
    {
        inAOtrosExprUnaria(node);
        if(node.getExprPrimaria() != null)
        {
            ponValor(node.getExprPrimaria(), cogeValor(node));
            node.getExprPrimaria().apply(this);
        }
        outAOtrosExprUnaria(node);
    }

    public void inAMultExprMult(AMultExprMult node)
    {
        defaultIn(node);
    }

    public void outAMultExprMult(AMultExprMult node)
    {
        defaultOut(node);
    }

    public void caseAMultExprMult(AMultExprMult node)
    {
        inAMultExprMult(node);
        if(node.getExprMult() != null)
        {
            ponValor(node.getExprMult(), cogeValor(node));
            node.getExprMult().apply(this);
        }
        if(node.getAsterisco() != null)
        {
            node.getAsterisco().apply(this);
        }
        System.out.print(node.getAsterisco()); //Imprimimos '*'

        if(node.getExprUnaria() != null)
        {
            ponValor(node.getExprUnaria(), 0);
            node.getExprUnaria().apply(this);
        }
        outAMultExprMult(node);
    }

    public void inADivExprMult(ADivExprMult node)
    {
        defaultIn(node);
    }

    public void outADivExprMult(ADivExprMult node)
    {
        defaultOut(node);
    }

    public void caseADivExprMult(ADivExprMult node)
    {
        inADivExprMult(node);
        if(node.getExprMult() != null)
        {
            ponValor(node.getExprMult(), cogeValor(node));
            node.getExprMult().apply(this);
        }
        if(node.getBarra() != null)
        {
            node.getBarra().apply(this);
        }
        System.out.print(node.getBarra()); //Imprimimos '/'

        if(node.getExprUnaria() != null)
        {
            ponValor(node.getExprUnaria(), 0);
            node.getExprUnaria().apply(this);
        }
        outADivExprMult(node);
    }

    public void inAOtroExprMult(AOtroExprMult node)
    {
        defaultIn(node);
    }

    public void outAOtroExprMult(AOtroExprMult node)
    {
        defaultOut(node);
    }

    public void caseAOtroExprMult(AOtroExprMult node)
    {
        inAOtroExprMult(node);
        if(node.getExprUnaria() != null)
        {
            ponValor(node.getExprUnaria(), cogeValor(node));
            node.getExprUnaria().apply(this);
        }
        outAOtroExprMult(node);
    }

    public void inASumaExprSuma(ASumaExprSuma node)
    {
        defaultIn(node);
    }

    public void outASumaExprSuma(ASumaExprSuma node)
    {
        defaultOut(node);
    }

    public void caseASumaExprSuma(ASumaExprSuma node)
    {
        inASumaExprSuma(node);
        if(node.getExprSuma() != null)
        {
            ponValor(node.getExprSuma(), cogeValor(node));
            node.getExprSuma().apply(this);
        }
        if(node.getMas() != null)
        {
            node.getMas().apply(this);
        }
        System.out.print(node.getMas()); //Imprimimos '+'

        if(node.getExprMult() != null)
        {
            ponValor(node.getExprMult(), 0);
            node.getExprMult().apply(this);
        }
        outASumaExprSuma(node);
    }

    public void inARestaExprSuma(ARestaExprSuma node)
    {
        defaultIn(node);
    }

    public void outARestaExprSuma(ARestaExprSuma node)
    {
        defaultOut(node);
    }

    public void caseARestaExprSuma(ARestaExprSuma node)
    {
        inARestaExprSuma(node);
        if(node.getExprSuma() != null)
        {
            ponValor(node.getExprSuma(), cogeValor(node));
            node.getExprSuma().apply(this);
        }
        if(node.getMenos() != null)
        {
            node.getMenos().apply(this);
        }
        System.out.print(node.getMenos()); //Imprimimos '-'

        if(node.getExprMult() != null)
        {
            ponValor(node.getExprMult(), 0);
            node.getExprMult().apply(this);
        }
        outARestaExprSuma(node);
    }

    public void inAOtroExprSuma(AOtroExprSuma node)
    {
        defaultIn(node);
    }

    public void outAOtroExprSuma(AOtroExprSuma node)
    {
        defaultOut(node);
    }

    public void caseAOtroExprSuma(AOtroExprSuma node)
    {
        inAOtroExprSuma(node);
        if(node.getExprMult() != null)
        {
            ponValor(node.getExprMult(), cogeValor(node));
            node.getExprMult().apply(this);
        }
        outAOtroExprSuma(node);
    }

    public void inAMenorExprRelac(AMenorExprRelac node)
    {
        defaultIn(node);
    }

    public void outAMenorExprRelac(AMenorExprRelac node)
    {
        defaultOut(node);
    }

    public void caseAMenorExprRelac(AMenorExprRelac node)
    {
        inAMenorExprRelac(node);
        if(node.getExprRelac() != null)
        {
            ponValor(node.getExprRelac(), cogeValor(node));
            node.getExprRelac().apply(this);
        }
        if(node.getMenor() != null)
        {
            node.getMenor().apply(this);
        }
        System.out.print(node.getMenor()); //Imprimimos '<'

        if(node.getExprSuma() != null)
        {
            ponValor(node.getExprSuma(), 0);
            node.getExprSuma().apply(this);
        }
        outAMenorExprRelac(node);
    }

    public void inAMenorIgExprRelac(AMenorIgExprRelac node)
    {
        defaultIn(node);
    }

    public void outAMenorIgExprRelac(AMenorIgExprRelac node)
    {
        defaultOut(node);
    }

    public void caseAMenorIgExprRelac(AMenorIgExprRelac node)
    {
        inAMenorIgExprRelac(node);
        if(node.getExprRelac() != null)
        {
            ponValor(node.getExprRelac(), cogeValor(node));
            node.getExprRelac().apply(this);
        }
        if(node.getMenorIg() != null)
        {
            node.getMenorIg().apply(this);
        }
        System.out.print(node.getMenorIg()); //Imprimimos '<='

        if(node.getExprSuma() != null)
        {
            ponValor(node.getExprSuma(), 0);
            node.getExprSuma().apply(this);
        }
        outAMenorIgExprRelac(node);
    }

    public void inAMayorExprRelac(AMayorExprRelac node)
    {
        defaultIn(node);
    }

    public void outAMayorExprRelac(AMayorExprRelac node)
    {
        defaultOut(node);
    }

    public void caseAMayorExprRelac(AMayorExprRelac node)
    {
        inAMayorExprRelac(node);
        if(node.getExprRelac() != null)
        {
            ponValor(node.getExprRelac(), cogeValor(node));
            node.getExprRelac().apply(this);
        }
        if(node.getMayor() != null)
        {
            node.getMayor().apply(this);
        }
        System.out.print(node.getMayor()); //Imprimimos '>'

        if(node.getExprSuma() != null)
        {
            ponValor(node.getExprSuma(), 0);
            node.getExprSuma().apply(this);
        }
        outAMayorExprRelac(node);
    }

    public void inAMayorIgExprRelac(AMayorIgExprRelac node)
    {
        defaultIn(node);
    }

    public void outAMayorIgExprRelac(AMayorIgExprRelac node)
    {
        defaultOut(node);
    }

    public void caseAMayorIgExprRelac(AMayorIgExprRelac node)
    {
        inAMayorIgExprRelac(node);
        if(node.getExprRelac() != null)
        {
            ponValor(node.getExprRelac(), cogeValor(node));
            node.getExprRelac().apply(this);
        }
        if(node.getMayorIg() != null)
        {
            node.getMayorIg().apply(this);
        }
        System.out.print(node.getMayorIg()); //Imprimimos '>='

        if(node.getExprSuma() != null)
        {
            ponValor(node.getExprSuma(), 0);
            node.getExprSuma().apply(this);
        }
        outAMayorIgExprRelac(node);
    }

    public void inAOtroExprRelac(AOtroExprRelac node)
    {
        defaultIn(node);
    }

    public void outAOtroExprRelac(AOtroExprRelac node)
    {
        defaultOut(node);
    }

    public void caseAOtroExprRelac(AOtroExprRelac node)
    {
        inAOtroExprRelac(node);
        if(node.getExprSuma() != null)
        {
            ponValor(node.getExprSuma(), cogeValor(node));
            node.getExprSuma().apply(this);
        }
        outAOtroExprRelac(node);
    }

    public void inAIgualExprIgualdad(AIgualExprIgualdad node)
    {
        defaultIn(node);
    }

    public void outAIgualExprIgualdad(AIgualExprIgualdad node)
    {
        defaultOut(node);
    }

    public void caseAIgualExprIgualdad(AIgualExprIgualdad node)
    {
        inAIgualExprIgualdad(node);
        if(node.getExprIgualdad() != null)
        {
            ponValor(node.getExprIgualdad(), cogeValor(node));
            node.getExprIgualdad().apply(this);
        }
        if(node.getOpIgual() != null)
        {
            node.getOpIgual().apply(this);
        }
        System.out.print(node.getOpIgual()); //Imprimimos '='

        if(node.getExprRelac() != null)
        {
            ponValor(node.getExprRelac(), 0);
            node.getExprRelac().apply(this);
        }
        outAIgualExprIgualdad(node);
    }

    public void inADistintoExprIgualdad(ADistintoExprIgualdad node)
    {
        defaultIn(node);
    }

    public void outADistintoExprIgualdad(ADistintoExprIgualdad node)
    {
        defaultOut(node);
    }

    public void caseADistintoExprIgualdad(ADistintoExprIgualdad node)
    {
        inADistintoExprIgualdad(node);
        if(node.getExprIgualdad() != null)
        {
            ponValor(node.getExprIgualdad(), cogeValor(node));
            node.getExprIgualdad().apply(this);
        }
        if(node.getOpNoIgual() != null)
        {
            node.getOpNoIgual().apply(this);
        }
        System.out.print(node.getOpNoIgual()); //Imprimimos '!='

        if(node.getExprRelac() != null)
        {
            ponValor(node.getExprRelac(), 0);
            node.getExprRelac().apply(this);
        }
        outADistintoExprIgualdad(node);
    }

    public void inAOtroExprIgualdad(AOtroExprIgualdad node)
    {
        defaultIn(node);
    }

    public void outAOtroExprIgualdad(AOtroExprIgualdad node)
    {
        defaultOut(node);
    }

    public void caseAOtroExprIgualdad(AOtroExprIgualdad node)
    {
        inAOtroExprIgualdad(node);
        if(node.getExprRelac() != null)
        {
            ponValor(node.getExprRelac(), cogeValor(node));
            node.getExprRelac().apply(this);
        }
        outAOtroExprIgualdad(node);
    }

    public void inAAndExprAnd(AAndExprAnd node)
    {
        defaultIn(node);
    }

    public void outAAndExprAnd(AAndExprAnd node)
    {
        defaultOut(node);
    }

    public void caseAAndExprAnd(AAndExprAnd node)
    {
        inAAndExprAnd(node);
        if(node.getExprAnd() != null)
        {
            ponValor(node.getExprAnd(), cogeValor(node));
            node.getExprAnd().apply(this);
        }
        if(node.getAmpAmp() != null)
        {
            node.getAmpAmp().apply(this);
        }
        System.out.print(node.getAmpAmp()); //Imprimimos '&&'

        if(node.getExprIgualdad() != null)
        {
            ponValor(node.getExprIgualdad(), 0);
            node.getExprIgualdad().apply(this);
        }
        outAAndExprAnd(node);
    }

    public void inAOtroExprAnd(AOtroExprAnd node)
    {
        defaultIn(node);
    }

    public void outAOtroExprAnd(AOtroExprAnd node)
    {
        defaultOut(node);
    }

    public void caseAOtroExprAnd(AOtroExprAnd node)
    {
        inAOtroExprAnd(node);
        if(node.getExprIgualdad() != null)
        {
            ponValor(node.getExprIgualdad(), cogeValor(node));
            node.getExprIgualdad().apply(this);
        }
        outAOtroExprAnd(node);
    }

    public void inAOrExpr(AOrExpr node)
    {
        defaultIn(node);
    }

    public void outAOrExpr(AOrExpr node)
    {
        defaultOut(node);
    }

    public void caseAOrExpr(AOrExpr node)
    {
        inAOrExpr(node);
        if(node.getExpr() != null)
        {
            ponValor(node.getExpr(), cogeValor(node));
            node.getExpr().apply(this);
        }
        if(node.getTubTub() != null)
        {
            node.getTubTub().apply(this);
        }
        System.out.print(node.getTubTub()); //Imprimimos '||'
        if(node.getExprAnd() != null)
        {
            ponValor(node.getExprAnd(), 0);
            node.getExprAnd().apply(this);
        }
        outAOrExpr(node);
    }

    public void inAOtroExpr(AOtroExpr node)
    {
        defaultIn(node);
    }

    public void outAOtroExpr(AOtroExpr node)
    {
        defaultOut(node);
    }

    public void caseAOtroExpr(AOtroExpr node)
    {
        inAOtroExpr(node);
        if(node.getExprAnd() != null)
        {
            ponValor(node.getExprAnd(), cogeValor(node));
            node.getExprAnd().apply(this);
        }
        outAOtroExpr(node);
    }
}
